Pixel reordering and selection logic

ABSTRACT

Presented herein are systems and methods for pixel reordering and selection. A decoded frame is stored in a frame buffer with a particular pixel order and byte order. A pixel feeder fetches portions of the decoded frame and stores portions of the frame in a double buffer with the same pixel order and byte order. An endian swizzle converts the byte ordering to a predetermined format, as needed. Reordering logic changes the pixel order to a predetermined order. Selection logic selects luma and chroma pixels from fetched pixels and provides the luma pixels to a luma pixel register, chroma Cr pixels to a chroma Cr pixel register, and chroma Cb pixels to a chroma Cb pixel register.

RELATED APPLICATIONS

This application claims priority to U.S. Patent Application Ser. No. 60/495,301, entitled “PIXEL REORDERING LOGIC FOR MULTIPLE FORMATS IN A FEEDER”, filed Aug. 14, 2003, by Hatti, et. al., which is incorporated herein by reference.

FEDERALLY SPONSORED RESEARCH OR DEVELOPMENT

[Not Applicable]

MICROFICHE/COPYRIGHT REFERENCE

[Not Applicable]

BACKGROUND OF THE INVENTION

A video decoder receives encoded video data and decodes and/or decompresses the video data. The decoded video data comprises a series of pictures. A display device displays the pictures. The pictures comprise a two-dimensional grid of pixels. The display device displays the pixels of each frame in real time at a constant rate. In contrast, the rate of decoding can vary considerably for different video data. Accordingly, the video decoder writes the decoded pictures in a frame buffer.

Among other things, a display engine is synchronized with the display device and provides the appropriate pixels to the display device for display. The display engine provides the appropriate pixels from the frame buffer to the display device. The location of the appropriate pixels in the frame buffer is dependent on the manner that the video decoder writes the pictures to the frame buffer.

Characteristics that characterize the manner that the video decoder writes the picture to the frame buffer include the packing of luma and chroma pixels, the linearity that the frame is stored, and the spatial relationship between the luma and chroma pixels. The foregoing characteristics are usually determined by the original format of the source video data.

The luma and chroma pixels of a picture can either be stored together or separately. The chroma pixels include chroma red difference pixels Cr, and chroma blue difference pixels Cb. In macroblock format, the luma Y pixels are stored in one array, while both chroma pixels Cr/Cb are stored together in another array. In planar format, the luma pixels Y are stored in one array, the chroma Cr pixels are stored in a second array, and the chroma Cb pixels are stored in a third array. In packed YUV format, the luma pixels and both the chroma Cr/Cb pixels are stored together in a single array.

In the packed YUV format, each alternating luma Y pixel is co-located with chroma pixels Cr&Cb in horizontal direction. A picture in the packed YUV format can be divided into units of four pixels, each of the units capable of being stored in a 32-bit word. The four pixels comprise adjacent luma Y pixels and the chroma pixels Cr/Cb co-located with one of the luma Y pixels. The luma Y pixels and the chroma pixels Cr/Cb can be packed in any one of several pixel orders. Examples of pixel orders that the luma Y pixels and chroma pixels Cr/Cb can be packed include, Cb₀/Y₀/Cr₀/Y₁, Cr₀/Y₀/Cb₀/Y₁, Y₀/Cb₀/Y₁/Cr₀, and Y₀/Cr₀/Y₁/Cb₀. Additionally, in big endian order, the four bytes are stored in a 32-bit dword as byte0/byte1/byte2/byte3. In little endian order, the four bytes are stored as byte3/byte2/byte1/byte0. Whether bytes are stored in big endian byte order or little endian byte order depends on the hardware characteristics of the frame buffer memory.

The video decoder does not necessarily store the picture in a linear manner. In planar and packed YUV formats, the video decoder stores pictures in linear format i.e., left to right and top to bottom order in the memory. However, in MPEG, DV25, and TM5, pictures are stored in the frame buffer in a macroblock format. In the macroblock format, the pixels of the picture are divided into two dimensional blocks. The video decoder stores the two dimensional blocks in consecutive memory locations.

Additionally, the spatial relationship of chroma pixels to luma pixels can differ among the many standards. Standards defining the spatial relationship of the chroma pixels to luma pixels include MPEG 4:2:0, MPEG 4:2:2, DV-25 4:2:0, and DV-25 4:1:1 to name a few. Where the standards for the display and the decoded video data differ, chroma pixels for the display can be interpolated from two or more chroma pixels in the decoded video data. The standard for the decoded video data is heavily dependent on the format of the source video data.

Conventionally, after each horizontal synchronization pulse, the host processor calculates the address of the first pixels of a line and the parameters for chroma format conversion. The host processor then programs the display engine with the foregoing.

Programming the display engine at each horizontal synchronization pulse consumes considerable bandwidth from the host processor.

Further limitations and disadvantages of conventional and traditional approaches will become apparent to one of skill in the art, through comparison of such systems with embodiments presented in the remainder of the present application with references to the drawings.

BRIEF SUMMARY OF THE INVENTION

Presented herein is a line address computer for calculating the line addresses of decoded video data.

In one embodiment, there is presented a method for displaying pictures. The method comprises fetching a portion of a picture stored in a frame buffer, the portion of the picture stored with a byte order, storing the portion of the picture in another buffer with the byte order, fetching a plurality of pixels from the portion of the picture, and converting the byte order of the plurality of pixels to a predetermined byte order, wherein the byte order is different from the predetermined byte order.

In another embodiment, there is presented a system for displaying pictures. The system comprises a first circuit, a buffer, a state machine, and a second circuit. The first circuit fetches a portion of a picture stored in a frame buffer, the portion of the picture stored with a byte order. The buffer stores the portion of the picture with the byte order. The state machine fetches a plurality of pixels from the portion of the picture. The second circuit converts the byte order of the plurality of pixels to a predetermined byte order, wherein the byte order is different from the predetermined byte order.

In another embodiment, there is presented a method for displaying pictures. The method comprises fetching a portion of a picture stored in a frame buffer, the portion of the picture stored with a pixel order, storing the portion of the picture in another buffer with the pixel order, fetching a plurality of pixels from the portion of the picture, converting the pixel order of the plurality of pixels to a predetermined pixel order.

In another embodiment, there is presented a system for displaying pictures. The system comprises a first circuit, a buffer, an input data write unit, and a second circuit. The first circuit fetches a portion of a picture stored in a frame buffer, the portion of the picture stored with a pixel order. The buffer stores the portion of the picture with the pixel order. The input data write unit fetches a plurality of pixels from the portion of the picture. The second circuit converts the pixel order of the plurality of pixels to a predetermined pixel order.

In another embodiment, there is presented a method for displaying pictures. The method comprises fetching a portion of a picture stored in a frame buffer, storing the portion of the picture in another buffer, fetching a plurality of pixels from the portion of the picture, storing luma pixels in a luma pixel register, wherein the plurality of pixels comprise luma pixels, and storing chroma pixels in a chroma pixel register, wherein the plurality of pixels comprise chroma pixels.

In another embodiment, there is presented a system for displaying pictures. The system comprises a first circuit, a buffer, a state machine, a luma pixel register, and a chroma pixel register. The first circuit fetches a portion of a picture stored in a frame buffer. The buffer stores the portion of the picture. The state machine fetches a plurality of pixels from the portion of the picture. The luma pixel register stores luma pixels, wherein the plurality of pixels comprise luma pixels. The chroma pixel register stores chroma pixels, wherein the plurality of pixels comprise chroma pixels.

These and other advantages and novel features of the present invention, as well as details of an illustrated embodiment thereof, will be more fully understood from the following description and drawings.

BRIEF DESCRIPTION OF SEVERAL VIEWS OF THE DRAWINGS

FIG. 1 is block diagram of an exemplary decoder system in accordance with an embodiment of the present invention;

FIG. 2 is a block diagram of an exemplary frame;

FIG. 3A is a block diagram of a frame buffer storing a frame in accordance with the MPEG, DV25 and TM5 formats;

FIG. 3B is a block diagram of a frame buffer storing a frame in accordance with the packed YUV format;

FIG. 3C is a block diagram of a frame buffer storing a frame in accordance with the planar format;

FIG. 4A is a block diagram of an exemplary gword storing packed YUV data in the big endian byte order;

FIG. 4B is a block diagram of an exemplary gword storing packed YUV data in the little endian byte order;

FIG. 5 is a block diagram of an exemplary gword storing MPEG/DV-25/TM5 pixels in the big endian byte order;

FIG. 6 is a block diagram of an exemplary display engine in accordance with an embodiment of the present invention;

FIG. 7 is a block diagram of a pixel feeder in accordance with an embodiment of the present invention;

FIG. 8 is a block diagram of the pixel feeder in accordance with an embodiment of the present invention;

FIG. 9 is a block diagram of an endian, swizzle in accordance with an embodiment of the present invention; and

FIG. 10 is a block diagram of pixel select logic in accordance with an embodiment of the present invention.

DETAILED DESCRIPTION OF THE INVENTION

Referring now to FIG. 1, there is illustrated a block diagram of an exemplary decoder system for decoding compressed video data, configured in accordance with an embodiment of the present invention. A processor, that may include a CPU 90, reads transport stream 65 into a transport stream buffer 32 within an SDRAM 30.

The data is output from the transport stream buffer 32 and is then passed to a data transport processor 35. The data transport processor 35 then demultiplexes the transport stream 65 into constituent transport streams. The constituent packetized elementary stream can include for example, video transport streams, and audio transport streams. The data transport processor 35 passes an audio transport stream to an audio decoder 60 and a video transport stream to a video transport processor 40.

The video transport processor 40 converts the video transport stream into a video elementary stream and provides the video elementary stream to a video decoder 45. The video decoder 45 decodes the video elementary stream, resulting in a sequence of decoded video frames. The decoding can include decompressing the video elementary stream. It is noted that there are various standards for compressing the amount of data required for transportation and storage of video data, such as MPEG-2.

The decoded video data includes a series of frames. The frames are stored in a frame buffer 48. The frame buffer 48 can be dynamic random access memory (DRAM) comprising 128 bit/16 byte gigantic words (gwords). It is also noted that in certain standards, such as MPEG-2, the order that frames are decoded is not necessarily the order that frames are presented. Accordingly, several pictures can be stored in the frame buffer 48 at a given time.

The display engine 50 is responsible for providing a bitstream to a display device, such as a monitor or a television. A display device displays the pictures in a specific predetermined display format with highly synchronized timing. The format dictates the order that different portions of a picture are displayed, as well as the positions of pixels.

Referring now to FIG. 2, there is illustrated a block diagram describing an exemplary picture 100. The picture 100 comprises any number of horizontal rows 100(0) . . . 100(N). Each row 100(0) . . . 100(N) includes a row of luma Y pixels, Y₀ . . . Y_(x), and half as many chroma Cr pixels Cr₀ . . . Cr_((x−1)/2) and half as many chroma Cb pixels Cb₀ . . . Cb_((x−1)/2). In a standard definition television picture 100, there are 480 rows (N=479), each comprising 720 luma Y pixels, 360 chroma Cr pixels, and 360 chroma Cb pixels.

The luma Y, chroma Cr, and chroma Cb pixels can be stored in one of several array formats. For example, in the packed YUV format, the luma Y, chroma Cr, and chroma Cb pixels are stored together in one array in linear format. In the planar format, the luma pixels, chroma Cr pixels, and chroma Cb pixels are each stored in separate arrays in linear format. In MPEG, DV25, and TM5, the luma pixels Y are stored in one array, while the chroma Cr and chroma Cb pixels are stored together in another array in macroblock format.

Referring now to FIG. 3A, there is illustrated a block diagram describing the frame buffer storing the picture 100 in accordance with an array format for the MPEG, DV25 and TM5 formats. The frame buffer 48 comprises two arrays 48Y, 48C of 16 byte/128 bit gwords 48Y(0), 48Y(1), 48Y(2), . . . , and 48C(0), 48C(1), 48C(2), . . . . The pixels luma pixels Y are stored in array 48Y. The chroma Cr and Cb pixels are stored in array 48C. The gwords 48Y(0), 48Y(1), . . . each store 16 horizontally adjacent luma pixels, Y_(16i) . . . Y_(16i+15) Each gword in array 48Y is associated with a gword in array 48C, wherein the associated gword in array 48C stores the chroma Cr and chroma Cb pixels co-located with the luma pixels Y_(16i) . . . Y_(16i+15.)

Referring now to FIG. 3B, there is illustrated a block diagram describing the frame buffer 48 storing picture 100 in accordance with the packed YUV array format. The frame buffer 48 comprises 16 byte/128 bit gwords 48(0), 48(1), 48(2), . . . . The pixels Y₀ . . . Y_(x), Cr₀ . . . Cr_((X-1)/2) in each row of the frame 100(0) . . . 100(N) are divided into units of four pixels U₀ . . . U_((x−1)/2). Each unit U_(i) comprises two luma pixels Y_(2i) and Y_(2i+1), and the chroma Cr_(i) pixels and chroma Cb_(i) pixels co-lcoated with luma pixels Y_(2i). The units U of each row 100(0) . . . 100(N) are stored from left to right U₀ . . . U_((x−1)/2) in consecutive four byte memory portions. The gwords 48(0), 48(1), . . . can store four units U_(4i), U_(4i+1), U_(4i+2), U_(4i+3), therein. The four pixels Y_(2i), Y_(2i+1), Cr_(i), Cb_(i) can be stored into four bytes in one of pixel orders, including, Cb_(i) Y_(2i) Cr_(i) Y_(2i+1), Cr_(i) Y_(2i) Cb_(i) Y_(2i+1), Y_(2i) Cr_(i) Y_(2i+1)Cb_(i), and Y_(2i) Cb_(i) Y_(2i+1) Cr_(i).

Referring now to FIG. 3C, there is illustrated a block diagram describing the frame buffer 48 storing picture 100 in accordance with the planar array format. The frame buffer 48 comprises three arrays 48Y, 48CR, 48CB of 16 byte/128 bit gwords 48Y(0), 48Y(1), 48Y(2), . . . , and 48C(0), 48C(1), 48C(2), . . . . The pixels luma pixels Y are stored in array 48Y. The chroma Cr are stored in array 48CR. The chroma Cb pixels are stored in array 48CB. The gwords 48Y(0), 48Y(1), . . . each store 16 horizontally adjacent luma pixels, Y_(16i) . . . Y_(16i+15). Each gword in array 48Y is associated with a gword half in array 48CR, and a gword half in array 48CB, wherein the associated gword half in array 48CR and array 48CB store the chroma Cr and chroma Cb pixels co-located with the luma pixels Y_(16i) . . . Y_(16i+)15.

The pixels can either be written in the bigendian byte order, byte0, byte1, byte2, byte3 or the little endian byte order byte3, byte2, byte1, byte0.

Referring now to FIG. 4A, there is illustrated a block diagram of an exemplary gword 48(i) storing data in the big endian byte order. The gword 48(i) comprises 128 bits, b₀ . . . b₁₂₇. In the big endian byte order, bytes are stored starting from bits b₀ . . . b₇. The units U_(4i), U_(4i+1), U_(4i+2), U_(4i+3) are stored in bits b₀ . . . b₃₁, b₃₂ . . . b₆₃, b₆₄ . . . b₉₅, b₉₆ . . . b₁₂₇, respectively. Additionally, the first, second, third, and fourth pixel of unit U_(4i) are stored in bits b₀ . . . b₇, b₈ . . . b₁₅, b₁₆ . . . b₂₃, are b₂₄ . . . b₃₁, respectively. If the pixels of units U_(4i), U_(4i+1), U_(4i+2), U_(4i+3) are in the pixel order Cb, Y₀, Cr, Y₁, the chroma Cb pixels in units U_(4i), U_(4i+1), U_(4i+2), U_(4i+3) are stored in bits b₀ . . . b₇, b₃₂ . . . b₃₉, b₆₄ . . . b₇₁, and b₉₆ . . . b₁₀₃, respectively. The first luma pixels (that is co-located with the chroma Cr and Cb pixels) Y₀ of units U_(4i), U_(4i+1), U_(4i+2), U_(4i+3) are stored in bits b₈ . . . b₁₅, b₄₀ . . . b₄₇, b₇₂ . . . b₇₉, and b₁₀₄ . . . b₁₁₁, respectively. The chroma Cb pixels in units U_(4i), U_(4i+1), U_(4i+2), U_(4i+3) are stored in bits b₁₆ . . . b₂₃, b₄₈ . . . b₅₅, b₈₀ . . . b₈₇, and b₁₁₂ . . . b₁₁₉, respectively. The second luma pixels (that is co-located with the chroma Cr and Cb pixels) Y₁ of units U_(4i), U_(4i+1), U_(4i+2), U_(4i+3) are stored in bits b₂₄ . . . b₃₁, b₅₆ . . . b₆₃, b₈₈ . . . b₉₅, and b₁₂₀ . . . b₁₂₇, respectively.

Referring now to FIG. 4B, there is illustrated a block diagram of an exemplary gword 48(i) storing data in the little endian byte order. The gword 48(i) comprises 128 bits, b₁₂₇ . . . b₀. In the little endian byte order, bytes are stored starting from bits b₁₂₇ . . . b₁₂₀. The units U_(4i), U_(4i+1), U_(4i+2), U_(4i+3) are stored in bits b₁₂₇ . . . b₉₆, b₉₅ . . . b₆₄, b₆₃ . . . b₃₂, b₃₁ . . . b₀ respectively. Additionally, the first, second, third, and fourth pixel of unit U_(4i) are stored in bits b₁₂₇ . . . b₁₂₀, b₁₁₉ . . . b₁₁₂, b₁₁₁ . . . b₁₀₄, are b₁₀₃ . . . b₉₆, respectively. If the pixels of units U_(4i), U_(4i+1), U_(4i+2), U_(4i+3) are in the pixel order Cb, Y₀, Cr, Y₁, the chroma Cb pixels in units U_(4i), U_(4i+1), U_(4i+2), U_(4i+3) are stored in bits b₁₂₇ . . . b₁₂₀, b₉₅ . . . b₆₈, b₆₃ . . . b₅₆, and b₃₁ . . . b₂₄, respectively. The first luma pixels (that is co-located with the chroma Cr and Cb pixels) Y₀ of units U_(4i), U_(4i+1), U_(4i+2), U_(4i+3) are stored in bits b₁₁₉ . . . b₁₁₂, b₈₇ . . . b₈₀, b₅₅ . . . b₄₈, and b₂₃ . . . b₁₆, respectively. The chroma Cb pixels in units U_(4i), U_(4i+1), U_(4i+2), U_(4i+3) are stored in bits b₁₁₁ . . . b₁₀₄, b₇₉ . . . b₇₂, b₄₇ . . . b₄₀, and b₁₅ . . . b₈, respectively. The second luma pixels (that is co-located with the chroma Cr and Cb pixels) Y₁ of units U_(4i), U_(4i+1), U_(4i+2), U_(4i+3) are stored in bits b₁₀₃ . . . b₉₆, b₇₁ . . . b₆₄, b₃₉ . . . b₃₂, and b₇ . . . b₀, respectively.

From the foregoing, it can be seen that the 32-bits storing a unit U are different. Additionally, in big endian, the lowest order bits store the first pixel while in little endian, the highest order bits store the first pixel.

Referring now to FIG. 5, there is illustrated a block diagram of an exemplary gword 48(i) storing data in the big endian byte order. The gword 48(i) comprises 128 bits, b₀ . . . b₁₂₇. In big endian order, bytes are stored starting from bits b₀ . . . b₇. For pixels Y_(16i) . . . Y_(16i+15), the pixel Y_(16i) is stored in bits b₀ . . . b₇, The pixel Y_(16i+1) is stored in bits b₈ . . . b₁₅, the pixel Y_(16i+2) is stored in bits b₁₆ . . . b₂₃, the pixel Y_(16i+3) is stored in bits b₂₄ . . . b₃₁, and the pixel Y_(16i+15) is stored in bits b₁₂₀ . . . b₁₂₇. For pixels Cr/Cb_(8i) . . . Cr/Cb_(8i+7), the pixel Cr_(8i) is stored in bits b₀ . . . b₇, pixel Cb_(8i) is stored in bits b₈ . . . b₁₅, pixel Cr_(8i+1) is stored in bits b₁₆ . . . b₂₃, pixel Cb_(8i+1) is stored in bits b₂₄ . . . b₃₁, pixel Cr_(8i+7) is stored in bits b₁₁₂ . . . b₁₁₉, pixel Cb_(8i+7) is stored in bits b₁₂₀ . . . b₁₂₇.

From the foregoing, it can be seen that the bits storing pixels are different. In the big endian byte order, the lowest order bits store the first pixel while in little endian byte order, the highest order bits store the first pixel.

The display device is usually separate from the decoder system. The display device displays the frames with highly synchronized timing. Each row 100(0) . . . 100(N) is displayed at a particular time interval. The display engine 50 provides the pixels to the display device for display, via the video encoder. The display device and the display engine 50 are synchronized by means of a vertical synchronization pulses and horizontal synchronization pulses. When the display device begins displaying a new frame 100 or field, the display device transmits a vertical synchronization pulse. Each time the display device begins displaying a new line 100(x), the display device sends a horizontal synchronization pulse. The display engine 50 uses the horizontal and vertical synchronization pulses to provide a stream comprising the pixels at a time related to the time for display.

The display engine 50 generates the bitstream from the decoded frames stored in the frame buffers 48. To generate the bitstream of the pixels for display on the display device, the display engine 50 fetches the pixels from the frame buffer 48. However, the decoded pictures may be progressive while the display device is interlaced. Additionally, the decoded picture may have chroma pixels in different positions from the display format. Additionally, the pixels of the decoded frame may be stored in a variety of different ways. For example, the chroma pixels can either be stored separately or with the luma pixels.

Where the decoded frame has a different chroma format from the display format, the chroma pixels for the chroma pixel positions in the display format are interpolated from the chroma format of the decoded frame.

Referring now to FIG. 6, there is illustrated a block diagram of the display engine 50 in accordance with an embodiment of the present invention. The display engine 50 includes a scalar 705, a compositor 710, a feeder 715, and a deinterlacing filter 720. The feeder 715 provides a bitstream of the pixels in the order the pixels are displayed for the display device. The bitstream comprises chroma pixels in the chroma pixel positions of the display format.

Referring now to FIG. 7, there is illustrated a block diagram describing an exemplary feeder 715 in accordance with an embodiment of the present invention. The feeder 715 provides a bitstream comprising pixels for display on the display device. The bitstream provides the pixels for display on the display device at a time related to the time the pixels are to be displayed by the display device. Additionally, the bitstream comprises chroma pixels in the chroma pixel positions in accordance with the display format. After each horizontal synchronization pulse, a row 100(x) is presented to the display device 65 for display.

After each vertical synchronization pulse, the host processor 90 programs the feeder 715 with the addresses of the frame buffer memory locations storing the first luma pixels, the first chroma pixel(s) for display (i.e., the left most pixels in row 100(0)), and the format of the decoded frame.

The foregoing parameters are provided to the feeder 715 via the RBUS interface 805. After providing the parameters to the RBUS interface 805, the host 90 sets a start parameter in the RBUS interface 805.

The RBUS interface 805 provides the initial starting luma and chroma addresses to the BRM 815. When the BRM 815 receives the starting luma and chroma addresses, the start parameter in the RBUS interface 805 is deasserted. The BRM 815 issues the commands for fetching the luma and chroma pixels in the first line of the frame/field. The IDWU 820 effectuates the commands.

The BRM 815 includes a command state machine 815 a and horizontal address computation logic 815 b. The command state machine 815 a can issue commands to the IDWU 820 causing the feeder 715 to fetch pixels from the frame buffer at a memory address provided by the command state machine 815 a. The command state machine initially commands the IDWU 820 to fetch the pixels starting at the starting luma and chroma addresses. The horizontal computation logic 815 b maintains the address of the frame buffer 48 location storing the next pixels in the display order.

The IDWU 820 writes the fetched pixels- to a double buffer 840 until the double buffer 840 is full. After the double buffer 840 is full, the double buffer machine detects when half of the data in the double buffer 840 is consumed. Responsive thereto, the command state machine 815 a commands the IDWU 820 to fetch the next pixels in the display order, starting at the address calculated by the horizontal address computation logic 815 b, until the double buffer 840 is full. The foregoing continues for each pixel in the first line 100(0).

A line address computer 810 calculates the address of the memory locations storing the starting pixels of the next line, e.g., line 100(1) if a progressive display or line 100 (2) if an interlaced display. The BRM 815 causes the IDWU 820 to start fetching pixels form the provided starting address. For each horizontal synchronization pulse, the line address computer 810 provides the address of the memory locations storing the first pixel (leftmost) of a row of luma pixels. The line address computer 810 provides the address storing the first pixel of consecutive rows of luma pixels 100(0), 100(1), . . . , 100(N) if the display is progressive. The line address computer 810 provides the address storing the first pixel of alternating rows of luma pixels 100(0), 100(2), . . . , 100(N-1), 100(1), 100(3) . . . 100(N) if the display device 65 is interlaced. The line address computer 810 is described in more detail in U.S. Patent Application Serial No. ______, filed Nov. 7, 2003, by Hatti, et. al. (Attorney Docket No. 15139US02), which is incorporated herein by reference.

Additionally, as noted above, the feeder 715 interpolates chroma pixels for the chroma pixel positions in the display picture from the pixels in the decoded picture.

At each horizontal synchronization pulse, the line address computer 810 provides interpolation weights, WCb_(T), WCb_(B), WCr_(T), and WCr_(B) for interpolation to a chroma filter. The interpolation weights depend on the decoded frame format, the display format, and the specific row with the chroma pixel positions.

A pixel feeder 835 comprises an endian swizzle & pixel select logic 835 a, a chroma filter data path 835 b, a chroma line buffer 835 c, an output data path 835 d, fixed color generation logic 835 e, and a double buffer read state machine 835 f. The double buffer state machine 835 f performs various duties that manage the pixel feeder 835. The duties include maintaining the double-buffer 840 status, reading pixels from the double buffer 840, sequencing the chroma filter datapath 835 b, and loading pixels onto the FIFO 830.

The pixels are fetched from the frame buffer and stored in the double buffer 840 in the same byte order, pixel order and array format that the pixels were stored in the frame buffer 48. The double buffer read state machine 835 f creates a rasterized data stream from the luma pixel data as well as associated chroma pixel bitstream(s). The luma pixel data stream and the chroma pixel bitstream(s) are synchronized with respect to each other, such that the luma pixels in the stream at a particular time and the chroma pixels in the stream(s) at a particular time are either co-located, or the pixels for interpolating the chroma pixels at chroma pixel positions co-located with the luma pixels.

Referring now to FIG. 8, there is illustrated a block diagram of the pixel feeder 835 in accordance with an embodiment of the present invention. The pixel feeder 835 includes a data path comprising the endian swizzle 835 a(1), pixel select logic 835 a(2), a 32-bit luma pixel register 905Y, a 16-bit chroma Cr pixel register 905R, and a 16-bit chroma Cb pixel register 905B.

The chroma Cr pixel register 905R and the chroma Cb pixel register 905B provide chroma Cr and chroma Cb pixels to the vertical chroma filter 835 by. The vertical chroma filter 835 by interpolates chroma pixels for the display format in the vertical direction. The output of the vertical chroma filter 835 by is provided to the horizontal chroma filter 835 bh. The horizontal chroma filter 835 bh interpolates chroma pixels for the display format in the horizontal direction.

A FIFO 830 receives the luma bitstream from the luma pixel register 905Y and a bitstream of interpolated chroma pixels. The FIFO 830 also receives signals from a bus protocol generator 825 to prepare the luma bitstream and interpolated chroma bitstream for transmission over a bus.

The double buffer state machine 835 f creates the bitstream of chroma and luma pixels by fetching chroma and luma pixels from the double buffer 840 at regular time intervals for the pixel registers 905. As noted above, the pixels are fetched from the frame buffer and stored in the double buffer 840 in the same byte order, pixel order and array format. The double buffer state machine 835 f fetches four pixels per double buffer 840 access. Because the pixels are stored in the double buffer 840 in the same byte order, pixel order and array format as stored in the frame buffer 48, the four pixels accessed during each access can include different types of pixels.

In the case of the packed YUV format, the pixel registers 905 are filled every two double buffer 840 accesses. One unit U is accessed during each access. Each unit U comprises two luma Y pixels, a chroma pixel Cr, and a chroma pixel Cb. The luma pixel register 905Y receives the four luma pixels Y, the chroma Cr pixel register 905R receives the two chroma pixels Cr, and the chroma Cb pixel register 905B receives the two chroma pixels Cb.

In the case of the MPEG/DV-25/TM5 formats, four luma pixels Y are fetched in one double buffer 840 access and provided to the luma pixel register 905Y. In the next double buffer 840 access, the two chroma Cr and the two chroma Cb pixels associated with the four luma pixels are fetched and provided to the chroma Cr pixel register 905R and chroma Cb pixel register 905B, respectively.

Additionally, either the big endian or little endian byte order can be used for storing the pixels in the double buffer 840. Therefore, the position of each particular pixel within the four bytes depends on whether the big endian or little endian byte order is used. For consistent handling, either the big endian byte order or the little endian order is chosen. Bytes of pixel data in the different or opposite byte order chosen can be reordered. The endian swizzle 835 a(1) reverses the ordering of the pixels from the double buffer 840 from either little endian to big endian, or big endian to little endian, when the byte order of the pixels is different or opposite the byte order chosen.

Because each double buffer 840 access can include a variety of different pixels therein, the pixel select logic 835 a(2) directs the pixels to the appropriate pixel registers 905.

Referring now to FIG. 9, there is illustrated a block diagram of the endian swizzle 835 a(1) in accordance with an embodiment of the present invention. The endian swizzle 835 a(1) receives the four pixels/32-bit access from the double buffer 840. The 32-bit access is demultiplexed into four bytes B₀, B₁, B₂, and B₃, each byte corresponding to a pixel. The endian swizzle 835 a(1) includes four multiplexers 1005(0), 1005(1), 1005(2), and 1005(3).

If a different or opposite byte ordering is used for the pixels, then the byte order chosen, B₀ in the original byte order corresponds to B₃ of the chosen byte order. B₁ in the little endian order corresponds to B₂ Of the chosen byte order. B₂ in the little endian order corresponds to B₁ of the chosen byte order. B₃ in the little endian order corresponds to B₀ of the chosen byte order.

Accordingly, multiplexers 1005(0) and 1005(3) receive bytes B₀ and B₃. Multiplexers 1005(1) and 1005(2) receive bytes B₁ and B₂. If the original byte order is different or opposite the chosen byte order, bytes B₀ and B₃ are swapped and bytes B₁ and B₂ are swapped. Multiplexer 1005(0) selects byte B₃, multiplexer 1005(1) selects byte B₂, multiplexer 1005(2) selects byte B₁, and multiplexer 1005(3) selects byte B₀. The outputs of the multiplexers 1005 are multiplexed to result in the 32-bit access converted to the big-endian byte order, e.g., B₃, B₂, B₁, B₀. If the original byte order is the same as the chosen byte order, the byte ordering is maintained. Multiplexer 1005(3) selects byte B₃, multiplexer 1005(2) selects byte B₂, multiplexer 1005(1) selects byte B₁, and multiplexer 1005(0) selects byte B₀. The outputs of the multiplexers 1005 are multiplexed to result in the original 32-bit access, e.g., B₀, B₁, B₂, B₃. The multiplexers 1005 are controlled by a signal Byte_In_DW_endian_Sel indicating whether a different or opposite byte order is originally used (1 indicates used, 0 indicates not used, for example) provided by the double buffer read state machine 835 f to effectuate the foregoing.

Referring now to FIG. 10, there is illustrated a block diagram describing an exemplary pixel select logic 835 a(2) in accordance with an embodiment of the present invention. The pixel select logic 835 a(2) comprises YUV reordering logic 1100 and selection logic 1200.

The pixel select logic 835 a(2) receives the output b₃₁ . . . b₀ from the endian swizzle 835 a(1). Three data paths provide the output b₃₁ . . . b₀ from the endian swizzle 835 a(1) to the selection logic—the luma pixel path 1255, the chroma pixel path 1260, and the packed YUV path 1265. The packed YUV path includes a YUV repacking logic 1100.

As noted above, where the frame 100 is stored in the packed YUV array format, the double buffer read state machine 835 f accesses one unit Upper access. The unit U comprises two luma pixels, a chroma pixel Cr, and a chroma pixel Cb. However, the pixel order within the unit U can vary.

Accordingly, the YUV reordering logic 1100 demultiplexes b₃₁ . . . b₀ into four bytes, b₃₁ . . . b₂₄, b₂₃ . . . b₁₆, b₁₅ . . . b₈, and b₇ . . . b₀. Each of the four bytes, b₃₁ . . . b₂₄, b₂₃ . . . b₁₆, b₁₅ . . . b₈, and b₇ . . . b₀, are provided to multiplexers 1205(0), 1205(1), 1205(2), 1205(3). Each multiplexer 1205 is configured to reorder pixels from a particular packed YUV format pixel order, to Y_(2i), Y_(2i+1), Cb_(i), Cr_(i).

For example, multiplexer 1205(0) changes the packed YUV pixel order Cb_(i), Y_(2i), Cr_(i), Y_(2i+1) to Y_(2i), Y_(2i+1), Cb_(i), Cr_(i). Accordingly, the multiplexer 1205(0) reorders the bytes b₃₁ . . . b₂₄, b₂₃ . . . b₁₆, b₁₅ . . . b₈, and b₇ . . . b₀, as b₂₃ . . . b₁₆, b₇ . . . b₀, b₃₁ . . . b₂₄, b₁₅ . . . b₈.

Multiplexer 1205(1) changes the packed YUV pixel order format Cr_(i), Y_(2i), Cb_(i), Y_(2i+1) to Y_(2i), Y_(2i+1), Cb_(i), Cr_(i). Accordingly, the multiplexer 1205(1) reorders the bytes b₃₁ . . . b₂₄, b₂₃ . . . b₁₆, b₁₅ . . . b₈, and b₇ . . . b₀, as b₂₃ . . . b₁₆, b₇ . . . b₀, b₁₅ . . . b₈, b₃₁ . . . b₂₄.

Multiplexer 1205(2) changes the packed YUV pixel order Y_(2i), Cb_(i), Y_(2i+1), Cr_(i) to Y_(2i), Y_(2i+1), Cb_(i), Cr_(i). Accordingly, the multiplexer 1205(2) reorders the bytes b₃₁ . . . b₂₄, b₂₃ . . . b₁₆, b₁₅ . . . b₈, and b₇ . . . b₀, as b₃₁ . . . b₂₄, b₁₅ . . . b₈, b₂₃ . . . b₁₆, b₇ . . . bo.

Multiplexer 1205(3) changes the packed YUV pixel order Y_(2i), Cr_(i), Y_(2i+1), Cb_(i) to Y_(2i), Y_(2i+1), Cb_(i), Cr_(i). Accordingly, the multiplexer 1205(3) reorders the bytes b₃₁ . . . b₂₄, b₂₃ . . . b₁₆, b₁ . . . b₈, and b₇ . . . b₀, as b₃₁ . . . b₂₄, b₁₅ . . . b₈, b₇ . . . b₀, b₂₃ . . . b₁₆.

The another multiplexer 1210 receives the outputs of the multiplexers 1205 and selects the multiplexer 1205 corresponding to the packed YUV pixel order of the fetched pixels. The double buffer read engine 835 f provides a signal, PackedYUV _DW_Type_Sel indicating the packed YUV format pixel order of the pixels in the frame buffer/double buffer 840 (0=>Cb_(i), Y_(2i), Cr_(i), Y_(2i+1), 1=>Cr_(i), Y_(2i), Cb_(i), Y_(2i+1), 2=>Y_(2i), Cb_(i), . . . Y_(2i+1), Cr_(i), 3=>Y_(2i), Cr_(i), Y_(2i+1), Cb_(i)) to the multiplexer 1210. The signal PackedYUV_DW_Type_Sel, causes the multiplexer 1205 to select the multiplexer 1205 associated with the indicated packed YUV pixel order. The output of multiplexer 1210 is then demultiplexed to separate the two luma pixels Y_(2i), Y_(2i+1), the chroma pixel Cb_(i) and the chroma pixel Cr_(i).

The selection logic 1200 receives pixels via the luma path 1255, the chroma path 1260, and the packed YUV path 1265. The signal on the luma path 1255 is demultiplexed into two 16-bit components, b₃₁ . . . b₁₆, and b₁₅ . . . b₀. The signal on the chroma path 1260 is demultiplexed into four 8-bit components, b₃₁ . . . b₂₄, b₂₃ . . . b₁₆, b₁₅ . . . b₈, and b₇ . . . b₀. The selection logic comprises six multiplexers 1205Y(1), 1205Y(0), 1205B(1), 1205B(0), 1205R(1), and 1205(0). The luma pixel register 905Y receives a 16-bit output b₃₁ . . . b₁₆ output from multiplexer 1205Y(1) and a 16-bit output from multiplexer 1205Y(0) b₁₅ . . . b₀. The chroma Cb pixel register 905B receives an 8-bit output b₁₅ . . . b₈ from multiplexer 1205B(1) and an 8-bit output from multiplexer 1205B(0). The chroma Cb pixel register 905R receives an 8-bit output b₁₅ . . . b₈ from multiplexer 1205R(1) and an 8-bit output from multiplexer 1205R(0).

The multiplexer 1205Y(1) receives the luma pixels Y_(2i), Y_(2i+1) from the packed Y V path 1260 and bits b₃₁ . . . b₁₆ from the luma path 1255. Multiplexer 1205Y(0) receives the luma pixels Y_(2i), Y_(2i+1) from the packed YUV path 1260 and bits b₁₅ . . . b₀ from the luma path 1255.

The multiplexer 1205B(1) receives a chroma pixel Cb_(i) from the packed YUV path 1260 and bits b₃₁ . . . b₂₄ from the chroma path 1265. The multiplexer 1205B(0) receives a chroma pixel Cb_(i) from the packed YUV path 1260 and bits b₂₃ . . . b₁₆ from the chroma path 1265.

The multiplexer 1205R(1) receives a chroma pixel Cr_(i) from the packed YUV path 1260 and bits b₁₅ . . . b₈ from the chroma path 1265. The multiplexer 1205B(0) receives a chroma pixel Cb_(i) from the packed YUV path 1260 and bits b₇ . . . b₀ from the chroma path 1265.

Each of the multiplexers 1205 are controlled by a signal Packed_YUV provided by the double buffer read state machine 835 f. When the picture 100 is in MPEG/DV-25/TM5 format, the luma path 1255 and chroma path 1265 carry four luma pixels Y_(4i), Y_(4i+1), Y_(4i+2), Y_(4i+3) during one double buffer 840 access, followed by two chroma pixels Cb_(2i), Cb_(2i+1), and two chroma pixels Cr_(2i), Cr_(2i+1), during the next double buffer 840 access, in alternating fashion. The multiplexers 1205Y(1) and 1205Y(0) select the respective portions of the luma path 1255. The multiplexers 1205B(1) 1205B(0), 1205R(1), and 1205R(0) select the respective portions of the chroma path 1265.

When the picture 100 is in the packed YUV array format, the packed YUV path 1260 carries two luma pixels Y_(2i), Y_(2i+1), and chroma pixels Cb_(i), and Cr_(i) during each access. Each of the multiplexers 1205 selects the respective portions of the packed YUV path 1260.

The pixel registers 905 load the outputs from the multiplexers 1205 connected thereto, responsive to a control signals 910 provided by the double buffer read state machine 835 f. As noted above, when the frame 100 is stored in the array format for MPEG/DV-25/TM5, double buffer 840 accesses provide either four luma pixels or two chroma Cr and two chroma Cb pixels, and in alternating fashion.

Accordingly, when the double buffer 840 access provides four luma pixels, the control signals 910Y(1), 910Y(0) controlling the luma pixel register 905 is asserted, causing the luma pixel register 905 to load the outputs of multiplexers 905Y(1), and 905Y(0).

When the double buffer 840 access provides chroma pixels, the control signals 910B(1), 910B(0), 910R(1), and 910R(0) controlling the chroma Cr pixel register 905R and the chroma Cb pixel register 905B are asserted, causing the chroma Cr pixel register 905R and chroma Cb pixel register 905B to load the outputs of multiplexers 905B(1), 905B(0) and multiplexers 905R(1), 905R(0). The foregoing results in pixel registers 905Y, 905B, and 905R to store four luma pixels, two chroma Cb pixels, and two chroma Cr pixels, respectively, after every two double buffer 840 accesses, wherein the chroma pixels are associated with the luma pixels. For example, the chroma pixels can be co-located with the luma pixels in the picture 100.

When the picture 100 is stored in the Packed YUV array format, double buffer 840 accesses provides two luma pixels, a chroma Cr and chroma Cb pixel. The control signals 910Y(1), 910B(1), and 910R(1) control a half of registers 905Y, 905B, and 905R storing the most significant bytes. The control signals 910Y(0), 910B(0), and 910R(0) control a half of registers 905Y, 905B, and 905R storing the least significant bytes. The control signals 910Y(1), 910B(1), and 910R(1) are asserted in alternating fashion with control signals 910Y(0), 910B(0), and 910R(0) causing the pixel registers 905Y, 905B, and 905R to store four luma pixels, two chroma Cb pixels, and two chroma Cr pixels after every two double buffer 840 accesses, wherein the chronia pixels are associated with the luma pixels. For example, the chroma pixels are co-located with the luma pixels in the picture 100.

One embodiment of the present invention may be implemented as a board level product, as a single chip, application specific integrated circuit (ASIC), or with varying levels integrated on a single chip with other portions of the system as separate components.

The degree of integration of the system will primarily be determined by speed and cost considerations. Because of the sophisticated nature of modern processors, it is possible to utilize a commercially available processor, which may be implemented external to an ASIC implementation of the present system.

Alternatively, if the processor is available as an ASIC core or logic block, then the commercially available processor can be implemented as part of an ASIC device with various functions implemented as firmware.

While the invention has been described with reference to certain embodiments, it will be understood by those skilled in the art that various changes may be made and equivalents may be substituted without departing from the scope of the invention. In addition, many modifications may be made to adapt particular situation or material to the teachings of the invention without departing from its scope.

Therefore, it is intended that the invention not be limited to the particular embodiment(s) disclosed, but that the invention will include all embodiments falling within the scope of the appended claims. 

1. A method for displaying frames, said method comprising: fetching a portion of a frame stored in a frame buffer, the portion of the frame stored with a byte order; storing the portion of the frame in another buffer with the byte order; fetching a plurality of pixels from the portion of the frame; and converting the byte order of the plurality of pixels to a predetermined byte order, the byte order being different from the predetermined byte order.
 2. The method of claim 1, further comprising: decoding the frame; and storing the frame in the frame buffer with the byte order.
 3. The method of claim 1, wherein the another buffer forms a portion of a display engine.
 4. The method of claim 3, wherein the another buffer forms a portion of a pixel feeder.
 5. The method of claim 1, wherein the predetermined order is selected from a group consisting of big endian byte order and little endian byte order.
 6. The method of claim 1, further comprising: providing an indicator indicating whether the byte order is different or opposite from the predetermined order.
 7. The method of claim 6, further comprising: swapping a first one of the plurality of pixels and a second one of the plurality of pixels if the indicator indicates that the byte order is different or opposite from the predetermined order; and swapping a third one of the plurality of pixels and a fourth one of the plurality of pixels if the indicator indicates that the byte order is different or opposite from the predetermined order.
 8. A system for displaying pictures, said system comprising: a first circuit for fetching a portion of a picture stored in a frame buffer, the portion of the picture being stored with a byte order; a buffer for storing the portion of the picture with the byte order; a state machine for fetching a plurality of pixels from the portion of the picture; and a second circuit for converting the byte order of the plurality of pixels to a predetermined byte order, the byte order being different from the predetermined byte order.
 9. The system of claim 8, further comprising: a video decoder for decoding the frame; and the frame buffer for storing the frame with the byte order.
 10. The system of claim 8, wherein the first circuit comprises an input data write unit.
 11. The system of claim 8, wherein the buffer forms a portion of a display engine.
 12. The system of claim 10, wherein the buffer forms a portion of a pixel feeder.
 13. The system of claim 8, wherein the predetermined order is selected from a group consisting of big endian byte order and little endian byte order.
 14. The system of claim 8, wherein the state machine provides an indicator indicating whether the byte order is different or opposite from the predetermined order to the second circuit.
 15. The system of claim 14, wherein the second circuit further comprises: a first multiplexer for selecting one of a first one of the plurality of pixels and a second one of the plurality of pixels; a second multiplexer for selecting another of the first one of the plurality of pixels and the second one of the plurality of pixels, from the first multiplexer; a third multiplexer for selecting one of a third one of the plurality of pixels and a fourth one of the plurality of pixels; a fourth multiplexer for selecting another of the third one of the plurality of pixels and the fourth one of the plurality of pixels, from the third multiplexer; a fifth multiplexer for multiplexing outputs from the first multiplexer, the second multiplexer, the third multiplexer, and fourth multiplexer; and the selections of the first multiplexer, the second multiplexer, the third multiplexer, and the fourth multiplexer being controlled by the indicator provided by the state machine.
 16. A method for displaying frames, said method comprising: fetching a portion of a frame stored in a frame buffer, the portion of the frame being stored with a pixel order; storing the portion of the frame in another buffer with the pixel order; fetching a plurality of pixels from the portion of the frame; and converting the pixel order of the plurality of pixels to a predetermined pixel order.
 17. The method of claim 16, further comprising: decoding the frame; and storing the frame in the frame buffer with the byte order.
 18. The method of claim 16, wherein the another buffer forms a portion of a display engine.
 19. The method of claim 18, wherein the another buffer forms a portion of a pixel feeder.
 20. The method of claim 16, further comprising: rearranging the plurality of pixels in plurality of different pixel orders; receiving an indicator indicating the pixel order; and selecting the pixels rearranged in one of the plurality of different pixel orders based on the indicator indicating the pixel order.
 21. A system for displaying frames, said system comprising: a first circuit for fetching a portion of a frame stored in a frame buffer, the portion of the frame being stored with a pixel order; a buffer for storing the portion of the frame with the pixel order; an input data write unit for fetching a plurality of pixels from the portion of the frame; and a second circuit for converting the pixel order of the plurality of pixels to a predetermined pixel order.
 22. The system of claim 21, further comprising: a decoder for decoding the frame; and the frame buffer for storing the frame with the byte order.
 23. The system of claim of claim 21, wherein the buffer forms a portion of a display engine.
 24. The system of claim 23, wherein the buffer forms a portion of a pixel feeder.
 25. The system of claim 21, wherein the first circuit further comprises an input data write unit.
 26. The system of claim 21, wherein the second circuit further comprises: a demultiplexer for separating the plurality of pixels; a plurality of multiplexers for combining the separated plurality of pixels in a corresponding plurality of pixel orders; and another multiplexer for selecting an output from one of the plurality of multiplexers, based on an indicator indicating the pixel order provided by the state machine.
 27. A method for displaying frames, said method comprising: fetching a portion of a frame stored in a frame buffer; storing the portion of the frame in another buffer; fetching a plurality of pixels from the portion of the frame; storing luma pixels in a luma pixel register, if the plurality of pixels comprise luma pixels; and storing chroma pixels in a chroma pixel register, if the plurality of pixels comprise chroma pixels.
 28. The method of claim 27, further comprising: decoding the frame; and storing the frame in the frame buffer.
 29. The method of claim 27, wherein the another buffer forms a portion of a display engine.
 30. The method of claim 29, wherein the another buffer forms a portion of a pixel feeder.
 31. The method of claim 27, wherein storing the luma pixels in the luma pixel register further comprises: receiving the plurality of pixels; and providing the luma pixels to the luma pixel register, if the plurality of pixels comprise luma pixels.
 32. The method of claim 27, wherein storing the luma pixels in the luma pixel register further comprises: receiving the plurality of pixels over a first path; receiving a portion of the plurality of pixels over a second path; selecting the plurality of pixels from the first path, if all of the plurality of pixels are luma pixels; and selecting the portion of the plurality of pixels from the second path, if a portion of the plurality of pixels are luma pixels and another portion of the plurality of pixels are chroma pixels.
 33. The method of claim 27, wherein storing chroma pixels in the chroma pixel register further comprises: receiving the plurality of pixels; and providing the chroma pixels to the chroma pixel register, if the plurality of pixels comprise chroma pixels.
 34. The method of claim 27, wherein storing the chroma pixels in the chroma pixel register further comprises: receiving the plurality of pixels over a first path; receiving a portion of the plurality of pixels over a second path; selecting the plurality of pixels from the first path, if all of the plurality of pixels are chroma pixels; and selecting the portion of the plurality of pixels from the second path, if a port-ion of the plurality of pixels are chroma pixels and another portion of the plurality of pixels are luma pixels.
 35. The method of claim 27, wherein storing chroma pixels in the chroma pixel register further comprises: receiving the plurality of pixels; providing chroma Cr pixels to a chroma Cr pixel register, if the plurality of pixels comprise chroma Cr pixels; and providing chroma Cb pixels to a chroma Cb pixel register, if the plurality of pixels comprise chroma Cb pixels.
 36. The method of claim 27, wherein storing the chroma pixels in the chroma pixel register further comprises: receiving the plurality of pixels over a first path; receiving a portion of the plurality of pixels over a second path; selecting the plurality of pixels from the first path, if all of the plurality of pixels are chroma pixels; and selecting the portion of the plurality of pixels from the second path, if a portion of the plurality of pixels are chroma pixels and another portion of the plurality of pixels are luma pixels.
 37. The method of claim 36, further comprising: storing at least one of the plurality of pixels in a chroma Cr pixel register, if the plurality of pixels are selected; storing at least one of the plurality of pixels in a chroma Cb pixel register, if the plurality of pixels are selected; storing at least one of the pixels from the portion of the plurality of pixels from the second path in the chroma Cr pixel register, if the portion of the plurality of pixels are selected; and storing at least one of the pixels from the portion of the plurality of pixels from the second path in the chroma Cb pixel register, if the portion of the plurality of pixels are selected.
 38. A system for displaying frames, said system comprising: a first circuit for fetching a portion of a frame stored in a frame buffer; a buffer for storing the portion of the frame; a state machine for fetching a plurality of pixels from the portion of the frame; a luma pixel register for storing luma pixels, if the plurality of pixels comprise luma pixels; and a chroma pixel register for storing chroma pixels, if the plurality of pixels comprise chroma pixels.
 39. The system of claim 38, further comprising: a video decoder for decoding the frame; and the frame buffer for storing the frame.
 40. The system of claim 38, wherein the buffer forms a portion of a display engine.
 41. The system of claim 40, wherein the buffer forms a portion of a pixel feeder.
 42. The system of claim 38, further comprising: a first multiplexer for receiving a first portion of the plurality of pixels over a first path, and for receiving a second portion of the plurality of pixels over a second path, the first multiplexer associated with a first portion of the luma pixel register; a second multiplexer for receiving a remainder of the plurality of pixels from the first portion of the plurality of pixels over a first path, and for receiving the second portion of the plurality of pixels, the second multiplexer associated with a second portion of the luma pixel register; and the first multiplexer provides the portion of the plurality of pixels to the first portion of the luma pixel registers and the second multiplexer provides the remainder of the plurality of the pixels to the second portion of the luma pixel register if the portion of the plurality of pixels and the remainder of the plurality of pixels comprise luma pixels; the state machine selects one of the first multiplexer and the second multiplexer, the selected one of the multiplexers providing the second portion of the pixels to the associated portion of the luma pixel register, if the plurality of pixels comprise luma and chroma pixels.
 43. The system of claim 38, further comprising: a first multiplexer for receiving a first portion of the plurality of pixels over a first path, and for receiving a second portion of the plurality of pixels over a second path, the first multiplexer associated with a first portion of the chroma pixel register; a second multiplexer for receiving a remainder of the plurality of pixels from the first portion of the plurality of pixels over a first path, and for receiving the second portion of the plurality of pixels., the second multiplexer associated with a second portion of the chroma pixel register; and the first multiplexer provides the portion of the plurality of pixels to the first portion of the luma pixel registers and the second multiplexer provides the remainder of the plurality of the pixels to the second portion of the luma pixel register if the portion of the plurality of pixels and the remainder of the plurality of pixels comprise chroma pixels; the state machine selects one of the first multiplexer and the second multiplexer, the selected one of the multiplexers providing the second portion of the plurality of pixels to the associated portion of the luma pixel register, if the plurality of pixels comprise luma and chroma pixels. 